import axios from 'axios';

// API配置
const API_CONFIG = {
  READ_API: 'http://localhost:5242/api',
  WRITE_API: 'http://localhost:5004/api'
};

// 响应数据接口
interface ResponseData<T = any> {
  code: number;
  msg: string;
  data: T;
}

// 创建axios实例
const service = axios.create({
  baseURL: API_CONFIG.READ_API, // 默认使用Read API
  timeout: 10000,
  headers: {
    'Content-Type': 'application/json;charset=utf-8'
  }
});

// 请求拦截器
service.interceptors.request.use(
  (config: any) => {
    // 从localStorage获取token
    const token = localStorage.getItem('token');
    // 如果有token则携带在请求头中
    // 登录接口不需要token，跳过
    if (token && !config.url?.includes('/Auth/login')) {
      config.headers['Authorization'] = `Bearer ${token}`;
    }
    return config;
  },
  (error: any) => {
    console.log('请求错误：', error);
    return Promise.reject(error);
  }
);

// 响应拦截器
service.interceptors.response.use(
  (response: any) => {
    // 获取接口返回结果
    const res = response.data;
    
    // 如果code为200，说明请求成功
    if (res.code === 200) {
      // 请求成功，返回整个响应数据
      return res;
    } else {
      // 请求失败，返回错误信息
      return Promise.reject(new Error(res.msg || '请求失败'));
    }
  },
  (error: any) => {
    console.log('响应错误：', error);
    // 统一处理网络请求错误
    let message = '网络请求失败';
    if (error.response) {
      switch (error.response.status) {
        case 401:
          message = '未授权，请重新登录';
          // 清除token并跳转到登录页
          localStorage.removeItem('token');
          window.location.href = '/login';
          break;
        case 403:
          message = '拒绝访问';
          break;
        case 404:
          message = '请求地址不存在';
          break;
        case 500:
          message = '服务器内部错误';
          break;
        default:
          message = `未知错误: ${error.message}`;
      }
    }
    
    return Promise.reject(error);
  }
);

// 统一的API调用方法
const apiCall = {
  // 读取操作（使用Read API）
  read: (url: string, method: 'get' | 'post' | 'put' | 'delete' = 'get', data?: any, params?: any) => {
    service.defaults.baseURL = API_CONFIG.READ_API;
    return service[method](url, data, { params });
  },
  
  // 写入操作（使用Write API）
  write: (url: string, method: 'get' | 'post' | 'put' | 'delete' = 'post', data?: any, params?: any) => {
    service.defaults.baseURL = API_CONFIG.WRITE_API;
    return service[method](url, data, { params });
  },
  
  // 登录特殊处理（使用Read API，但不经过标准响应拦截器）
  login: async (data: { usernameOrEmail: string; password: string; rememberMe: boolean }) => {
    try {
      // 为登录创建完全独立的axios实例，不经过任何拦截器
      const loginService = axios.create({
        baseURL: API_CONFIG.READ_API,
        timeout: 10000,
        headers: {
          'Content-Type': 'application/json;charset=utf-8'
        }
      });
      
      const response = await loginService.post('/Auth/login', data);
      // 登录接口直接返回原始响应，不经过任何拦截器
      return response.data;
    } catch (error: any) {
      // 处理登录错误
      if (error.response && error.response.data) {
        throw new Error(error.response.data.message || '登录失败');
      }
      throw new Error('登录失败，请检查网络连接');
    }
  }
};

// API接口映射
const api = {
  // 用户相关接口
  user: {
    // 登录接口
    login: apiCall.login,
    
    // 登出接口
    logout: () => apiCall.read('/user/logout', 'post'),
    
    // 获取用户信息
    getInfo: () => apiCall.read('/user/info'),
    
    // 注册接口
    register: (data: { username: string; password: string; email: string }) => 
      apiCall.read('/user/register', 'post', data)
  },

  // 退款申请相关接口
  refundApplication: {
    // 获取退款申请分页列表（读取操作）
    getPagedList: (params: any) => {
      const queryString = new URLSearchParams();
      Object.keys(params).forEach(key => {
        if (params[key] !== undefined && params[key] !== null) {
          queryString.append(key, params[key]);
        }
      });
      return apiCall.read(`/RefundApplication/list?${queryString.toString()}`);
    },
    
    // 获取退款申请详情（读取操作）
    getDetail: (id: number) => apiCall.read(`/RefundApplication/detail/${id}`),
    
    // 获取退款申请统计信息（读取操作）
    getStatistics: () => apiCall.read('/RefundApplication/statistics'),
    
    // 确认退款申请（写入操作）
    confirm: (data: any) => apiCall.write('/RefundApplicationWrite/confirm', 'post', data),
    
    // 拒绝退款申请（写入操作）
    reject: (data: any) => apiCall.write('/RefundApplicationWrite/reject', 'post', data),
    
    // 清除缓存（写入操作）
    clearCache: () => apiCall.write('/RefundApplication/clear-cache', 'post')
  },

  // 药品订单相关接口
  medicalOrder: {
    // 获取药品订单分页列表（读取操作）
    getPagedList: (params: any) => {
      const queryString = new URLSearchParams();
      Object.keys(params).forEach(key => {
        if (params[key] !== undefined && params[key] !== null) {
          queryString.append(key, params[key]);
        }
      });
      return apiCall.read(`/MedicalOrder/paged-list?${queryString.toString()}`);
    },
    
    // 获取药品订单详情（读取操作）
    getDetail: (id: number) => apiCall.read(`/MedicalOrder/detail/${id}`),
    
    // 获取药品订单统计信息（读取操作）
    getStatistics: () => apiCall.read('/MedicalOrder/statistics'),
    
    // 订单发货（写入操作）
    shipOrder: (data: any) => apiCall.read('/MedicalOrderWrite/ship', 'post', data),
    
    // 确认收货（写入操作）
    confirmReceipt: (data: any) => apiCall.read('/MedicalOrderWrite/confirm-receipt', 'post', data),
    
    // 获取物流公司列表（读取操作）
    getLogisticsCompanies: () => apiCall.read('/MedicalOrderWrite/logistics-companies'),
    
    // 获取物流追踪详情（读取操作）
    getLogisticsTracking: (orderId: number) => apiCall.read(`/MedicalOrderWrite/logistics-tracking/${orderId}`)
  },

  // 处方流转订单相关接口
  prescriptionOrder: {
    // 获取处方流转订单分页列表（读取操作）
    getPagedList: (params: any) => {
      const queryString = new URLSearchParams();
      Object.keys(params).forEach(key => {
        if (params[key] !== undefined && params[key] !== null) {
          queryString.append(key, params[key]);
        }
      });
      return apiCall.read(`/PrescriptionOrder/list?${queryString.toString()}`);
    },
    
    // 获取处方流转订单详情（读取操作）
    getDetail: (id: number) => apiCall.read(`/PrescriptionOrder/detail/${id}`),
    
    // 获取处方流转订单统计信息（读取操作）
    getStatistics: () => apiCall.read('/PrescriptionOrder/statistics'),
    
    // 删除处方流转订单（写入操作）
    delete: (id: number) => apiCall.write('/PrescriptionOrderWrite/delete', 'post', { id }),
    
    // 批量删除处方流转订单（写入操作）
    batchDelete: (ids: number[]) => apiCall.write('/PrescriptionOrderWrite/batch-delete', 'post', { ids })
  },

  // 挂号订单相关接口
  registrationOrder: {
    // 获取挂号订单分页列表（读取操作）
    getPagedList: (params: any) => {
      const queryString = new URLSearchParams();
      Object.keys(params).forEach(key => {
        if (params[key] !== undefined && params[key] !== null) {
          queryString.append(key, String(params[key]));
        }
      });
      return apiCall.read(`/RegistrationOrder/list?${queryString.toString()}`);
    },
    
    // 获取挂号订单详情（读取操作）
    getDetail: (id: number) => apiCall.read(`/RegistrationOrder/detail/${id}`),
    
    // 获取挂号订单统计信息（读取操作）
    getStatistics: () => apiCall.read('/RegistrationOrder/statistics'),
    
    // 批量删除挂号订单（写入操作）
    batchDelete: (ids: number[]) => apiCall.write('/RegistrationOrder/batch', 'delete', { ids })
  },

  // 问诊单相关接口
  consultationOrder: {
    // 获取问诊单分页列表（读取操作）
    getPagedList: (params: any) => {
      const queryString = new URLSearchParams();
      Object.keys(params).forEach(key => {
        if (params[key] !== undefined && params[key] !== null) {
          queryString.append(key, String(params[key]));
        }
      });
      return apiCall.read(`/ConsultationOrder/list?${queryString.toString()}`);
    },
    
    // 获取问诊单详情（读取操作）
    getDetail: (id: number) => apiCall.read(`/ConsultationOrder/detail/${id}`),
    
    // 获取问诊单统计信息（读取操作）
    getStatistics: () => apiCall.read('/ConsultationOrder/statistics'),
    
    // 删除问诊单（写入操作）
    delete: (id: number) => apiCall.write(`/ConsultationOrder/${id}`, 'delete'),
    
    // 批量删除问诊单（写入操作）
    batchDelete: (ids: number[]) => apiCall.write('/ConsultationOrder/batch', 'delete', { ids })
  }
};

export default api;
